import sun.misc.Queue;

import java.util.*;

public class prog {
    public static void main(String[] args) {
        List list=new ArrayList();
    }





    public static String func(String str1,String str2){
        StringBuffer sb=new StringBuffer();
        for(int i=0;i<str1.length();i++){
            char ch=str1.charAt(i);
            if(!str2.contains(ch+"")){
                sb.append(ch);
            }
        }
        return sb.toString();
    }
    public static void main2(String[] args) {
        String str1="hello bit";
        String str2="elt";
        String str=func(str1,str2);
        System.out.println(str);
    }







    public static void main1(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNext()){
            String str=scanner.nextLine();
            StringBuffer sb=new StringBuffer();
            for(int i=0;i<str.length();i++){
                char ch=str.charAt(i);
                if(!sb.toString().contains(ch+"")){
                    sb.append(ch);
                }
            }
            System.out.println(sb);
        }






//        Integer a=127;
//        Integer b=127;
//        System.out.println(a==b);
    }

}
//class MinStack {
//    private Stack<Integer> stack;
//    private Stack<Integer> minstack;
//    public MinStack() {
//        this.stack=new Stack<Integer>();
//        this.minstack=new Stack<Integer>();
//    }
//
//    public void push(int val) {
//        this.stack.push(val);
//        if(this.minstack.empty()){
//            this.minstack.push(val);
//        }else{
//            if(val<=this.minstack.peek()){
//                this.minstack.push(val);
//            }
//        }
//    }
//
//    public void pop() {
//        if(this.stack.empty()){
//            return ;
//        }
//        int tmp=this.stack.pop();
//        if(this.minstack.peek()==tmp){
//            this.minstack.pop();
//        }
//    }
//
//    public int top() {
//        return this.stack.peek();
//    }
//
//    public int getMin() {
//        return this.minstack.peek();
//    }
//}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */










//class MyStack {
//    private Queue<Integer> queue1;
//    private Queue<Integer> queue2;
//    /** Initialize your data structure here. */
//    public MyStack() {
//        this.queue1=new LinkedList<>();
//        this.queue2=new LinkedList<>();
//    }
//
//    /** Push element x onto stack. */
//    public void push(int x) {
//        if(this.empty()){
//            this.queue1.offer(x);
//        }else if(!this.queue1.isEmpty()){
//            this.queue1.offer(x);
//        }else{
//            this.queue2.offer(x);
//        }
//    }
//
//    /** Removes the element on top of the stack and returns that element. */
//    public int pop() {
//        if(this.empty()){
//            return -1;
//        }
//        if(!this.queue1.isEmpty()){
//            int size=this.queue1.size();
//            for(int i=0;i<size-1;i++){
//                this.queue2.offer(this.queue1.poll());
//            }
//            return this.queue1.poll();
//        }else{
//            int size=this.queue2.size();
//            for(int i=0;i<size-1;i++){
//                this.queue1.offer(this.queue2.poll());
//            }
//            return this.queue2.poll();
//        }
//    }
//
//    /** Get the top element. */
//    public int top() {
//        if(this.empty()){
//            return -1;
//        }
//        if(!this.queue1.isEmpty()){
//            int size=this.queue1.size();
//            int x=-1;
//            for(int i=0;i<size;i++){
//                x=this.queue1.poll();
//                this.queue2.offer(x);
//            }
//            return x;
//        }else{
//            int size=this.queue2.size();
//            int x=-1;
//            for(int i=0;i<size;i++){
//                x=this.queue2.poll();
//                this.queue1.offer(x);
//            }
//            return x;
//        }
//    }
//
//    /** Returns whether the stack is empty. */
//    public boolean empty() {
//        if(this.queue1.isEmpty()&&this.queue2.isEmpty()){
//            return true;
//        }
//        return false;
//    }
//}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */







class MyQueue {
    private Stack<Integer> stack1;
    private Stack<Integer> stack2;
    public MyQueue() {
        stack1=new Stack<Integer>();
        stack2=new Stack<Integer>();
    }

    public void push(int x) {
        stack1.push(x);
    }

    public int pop() {
        if(this.empty()){
            return -1;
        }
        if(this.stack2.empty()){
            while(!this.stack1.empty()){
                this.stack2.push(this.stack1.pop());
            }
        }
        return stack2.pop();
    }

    public int peek() {
        if(this.empty()){
            return -1;
        }
        if(this.stack2.empty()){
            while(!this.stack1.empty()){
                this.stack2.push(this.stack1.pop());
            }
        }
        return stack2.peek();
    }

    public boolean empty() {
        if(this.stack1.empty()&&this.stack2.empty()){
            return true;
        }
        return false;
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */










class MyCircularQueue {
    private int[] queue;
    private int front;
    private int rear;
    public MyCircularQueue(int k) {
        this.queue=new int[k+1];
        this.front=0;
        this.rear=0;
    }

    public boolean enQueue(int value) {
        if(this.isFull()){
            return false;
        }
        this.queue[this.rear]=value;
        this.rear=(this.rear+1)%queue.length;
        return true;
    }

    public boolean deQueue() {
        if(this.isEmpty()){
            return false;
        }
        this.front=(this.front+1)%queue.length;
        return true;
    }

    public int Front() {
        if(this.isEmpty()){
            return -1;
        }
        return this.queue[this.front];
    }

    public int Rear() {
        if(this.isEmpty()){
            return -1;
        }
        int tmp=(this.rear==0)?this.queue[this.queue.length-1]:this.queue[this.rear-1];
        return tmp;
    }

    public boolean isEmpty() {
        if(this.front==this.rear){
            return true;
        }
        return false;
    }

    public boolean isFull() {
        if((this.rear+1)%queue.length==this.front){
            return true;
        }
        return false;
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * boolean param_1 = obj.enQueue(value);
 * boolean param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * boolean param_5 = obj.isEmpty();
 * boolean param_6 = obj.isFull();
 */








class Solution {
    public boolean isValid(String s) {
        if(s==null||s.length()==0){
            return false;
        }
        Stack<Character> stack=new Stack<Character>();
        for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);
            if(ch=='('||ch=='['||ch=='{'){
                stack.push(ch);
            }else{
                if(stack.empty()){
                    return false;
                }
                char c=stack.peek();
                if(c=='('&&ch==')'||c=='['&&ch==']'||c=='{'&&ch=='}'){
                    stack.pop();
                }else{
                    return false;
                }
            }
        }
        if(!stack.empty()){
            return false;
        }
        return true;
    }
}